//mod  my_rust_owner;
//use  my_rust_owner ::owner_test;
//mod  my_rust_loop;
//use  my_rust_loop::loop_test;
//mod  my_rust_reference;
//use  my_rust_reference::reference_test;

//mod  my_rust_dangling_references;
//use  my_rust_dangling_references::dangling_reference_test;

//引入生命周期模块
//mod  life_time;
//use life_time::longest;
//use life_time::longests;

//模块引用
mod my_deref_mod {
    include!("./my_rust_deref.rs");
}

mod my_rust_drop;
//use ;
//引入闭包模块
//mod rust_Course;

//所有权共享机制 不可变引用
mod my_rust_rc_arc;

mod my_rust_loop;
mod my_rust_refcell_cell;

mod my_rust_weak_loop;

mod DoubleLinkedList;
mod my_rust_thread;

mod my_rust_global;

mod my_rust_error_result;

mod my_rust_unsafe_rust;

use my_lib;

mod my_rust_asm;

mod my_rust_macro;

mod my_rust_async_await;

fn main() {
    // println!("Hello, world!");

    //   循环
    //loop_test();

    // 所有权;
    //owner_test();

    //引用
    //reference_test();

    //悬垂指针

    //println!("{}",dangling_reference_test());

    //生命周期
    //let x =String::from("xxxxxxxxx");
    //let y =String::from("yyyyyyyyy");

    //println!("{0}",longests(&x));
    //println!("{0}",longest(&x,&y));

    //life_time::test();

    //rust_Course::test();

    //标准库 闭包 fnonce  所有权转移切只运行一次
    //rust_Course::fn_once_test();

    //rust_Course:: fn_mut_test();

    //my_deref_mod::run();

    //my_rust_drop::run();

    //编译器转为 rustrover
    //计数器指针
    //my_rust_rc_arc::run();

    //可变 内存指针
    //my_rust_refcell_cell::run();

    //weak 和循环引用
    //my_rust_weak_loop::Run();

    //DoubleLinkedList ::DoubleLinkedList::new(value)

    //线程
    //my_rust_thread ::Run();

    //全局变量
    //my_rust_global ::run();

    //错误处理
    //my_rust_error_result::run();

    //不安全代码
    //my_rust_unsafe_rust::run();

    //调用c 代码
    // println!("xplusy(3, 4) = {}", my_lib::xplusy_safe(3.0, 4.0));
    // println!("xmuly(3, 4) = {}", my_lib::xmuly_safe(3.0, 4.0));
    // rust_to_c();

    //rust 中写汇编语言
    // my_rust_asm::run();

    //宏编程
    //my_rust_macro::run();

    //异步编程
   let r = my_rust_async_await::run();
   futures::executor::block_on(r);//run 是用了async 修饰符 ，所以要用一个 executor 容器包裹才会执行
 

    //
}

//cargo.toml  中构建的链接
use my_lib::MathUtils;
pub fn rust_to_c() {
    println!("Rust 调用 C 代码示例");
    println!("===================");

    println!("xplusy(3, 4) = {}", my_lib::xplusy_safe(3.0, 4.0));
    println!("xmuly(3, 4) = {}", my_lib::xmuly_safe(3.0, 4.0));

    // 测试斐波那契数列
    println!("\n1. 斐波那契数列:");
    for i in 0..10 {
        println!("  fib({}) = {}", i, MathUtils::fibonacci(i));
    }

    // 测试素数判断
    println!("\n2. 素数检测:");
    let test_primes = [2, 3, 17, 25, 29, 100];
    for &num in &test_primes {
        println!("  {} 是素数: {}", num, MathUtils::is_prime(num));
    }

    // 测试最大公约数
    println!("\n3. 最大公约数:");
    let pairs = [(48, 18), (1071, 462), (17, 13)];
    for &(a, b) in &pairs {
        println!("  gcd({}, {}) = {}", a, b, MathUtils::gcd(a, b));
    }

    // 测试向量加法
    println!("\n4. 向量加法:");
    let vec_a = [1.0, 2.0, 3.0, 4.0, 5.0];
    let vec_b = [5.0, 4.0, 3.0, 2.0, 1.0];
    let result = MathUtils::vector_add(&vec_a, &vec_b);

    println!("  {:?} + {:?} = {:?}", vec_a, vec_b, result);

    // 性能测试
    println!("\n5. 性能测试 - 计算 fib(40):");
    use std::time::Instant;

    let start = Instant::now();
    let fib_40 = MathUtils::fibonacci(40);
    let duration = start.elapsed();

    println!("  fib(40) = {}", fib_40);
    println!("  耗时: {:?}", duration);
}
